home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / GNU_C++ / LIB / MAKE3761.LZH / info / make.info-8 < prev    next >
Encoding:
GNU Info File  |  1998-07-20  |  42.2 KB  |  761 lines
  1. This is Info file make.info, produced by Makeinfo version 1.67 from the
  2. input file make.texinfo.
  3.  
  4. INFO-DIR-SECTION The GNU make utility
  5. START-INFO-DIR-ENTRY
  6. * GNU make: (make.info).           The GNU make utility.
  7. END-INFO-DIR-ENTRY
  8.  
  9.    This file documents the GNU Make utility, which determines
  10. automatically which pieces of a large program need to be recompiled,
  11. and issues the commands to recompile them.
  12.  
  13.    This is Edition 0.51, last updated 26 Aug 1997, of `The GNU Make
  14. Manual', for `make', Version 3.76 Beta.
  15.  
  16.    Copyright (C) 1988, '89, '90, '91, '92, '93, '94, '95, '96, '97     Free
  17. Software Foundation, Inc.
  18.  
  19.    Permission is granted to make and distribute verbatim copies of this
  20. manual provided the copyright notice and this permission notice are
  21. preserved on all copies.
  22.  
  23.    Permission is granted to copy and distribute modified versions of
  24. this manual under the conditions for verbatim copying, provided that
  25. the entire resulting derived work is distributed under the terms of a
  26. permission notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that this permission notice may be stated in a
  31. translation approved by the Free Software Foundation.
  32.  
  34. File: make.info,  Node: Concept Index,  Next: Name Index,  Prev: Complex Makefile,  Up: Top
  35.  
  36. Index of Concepts
  37. *****************
  38.  
  39. * Menu:
  40.  
  41. * # (comments), in commands:             Commands.
  42. * # (comments), in makefile:             Makefile Contents.
  43. * #include:                              Automatic Dependencies.
  44. * $, in function call:                   Syntax of Functions.
  45. * $, in rules:                           Rule Syntax.
  46. * $, in variable name:                   Computed Names.
  47. * $, in variable reference:              Reference.
  48. * %, in pattern rules:                   Pattern Intro.
  49. * %, quoting in patsubst:                Text Functions.
  50. * %, quoting in static pattern:          Static Usage.
  51. * %, quoting in vpath:                   Selective Search.
  52. * %, quoting with \ (backslash) <1>:     Text Functions.
  53. * %, quoting with \ (backslash) <2>:     Selective Search.
  54. * %, quoting with \ (backslash):         Static Usage.
  55. * * (wildcard character):                Wildcards.
  56. * +, and define:                         Sequences.
  57. * +=:                                    Appending.
  58. * ,v (RCS file extension):               Catalogue of Rules.
  59. * - (in commands):                       Errors.
  60. * -, and define:                         Sequences.
  61. * --assume-new <1>:                      Options Summary.
  62. * --assume-new:                          Instead of Execution.
  63. * --assume-new, and recursion:           Options/Recursion.
  64. * --assume-old <1>:                      Options Summary.
  65. * --assume-old:                          Avoiding Compilation.
  66. * --assume-old, and recursion:           Options/Recursion.
  67. * --debug:                               Options Summary.
  68. * --directory <1>:                       Recursion.
  69. * --directory:                           Options Summary.
  70. * --directory, and --print-directory:    -w Option.
  71. * --directory, and recursion:            Options/Recursion.
  72. * --dry-run <1>:                         Echoing.
  73. * --dry-run <2>:                         Instead of Execution.
  74. * --dry-run:                             Options Summary.
  75. * --environment-overrides:               Options Summary.
  76. * --file <1>:                            Makefile Arguments.
  77. * --file <2>:                            Makefile Names.
  78. * --file:                                Options Summary.
  79. * --file, and recursion:                 Options/Recursion.
  80. * --help:                                Options Summary.
  81. * --ignore-errors <1>:                   Errors.
  82. * --ignore-errors:                       Options Summary.
  83. * --include-dir <1>:                     Options Summary.
  84. * --include-dir:                         Include.
  85. * --jobs <1>:                            Options Summary.
  86. * --jobs:                                Parallel.
  87. * --jobs, and recursion:                 Options/Recursion.
  88. * --just-print <1>:                      Options Summary.
  89. * --just-print <2>:                      Echoing.
  90. * --just-print:                          Instead of Execution.
  91. * --keep-going <1>:                      Errors.
  92. * --keep-going <2>:                      Options Summary.
  93. * --keep-going:                          Testing.
  94. * --load-average <1>:                    Parallel.
  95. * --load-average:                        Options Summary.
  96. * --makefile <1>:                        Makefile Names.
  97. * --makefile <2>:                        Options Summary.
  98. * --makefile:                            Makefile Arguments.
  99. * --max-load <1>:                        Options Summary.
  100. * --max-load:                            Parallel.
  101. * --new-file <1>:                        Instead of Execution.
  102. * --new-file:                            Options Summary.
  103. * --new-file, and recursion:             Options/Recursion.
  104. * --no-builtin-rules:                    Options Summary.
  105. * --no-keep-going:                       Options Summary.
  106. * --no-print-directory <1>:              -w Option.
  107. * --no-print-directory:                  Options Summary.
  108. * --old-file <1>:                        Avoiding Compilation.
  109. * --old-file:                            Options Summary.
  110. * --old-file, and recursion:             Options/Recursion.
  111. * --print-data-base:                     Options Summary.
  112. * --print-directory:                     Options Summary.
  113. * --print-directory, and --directory:    -w Option.
  114. * --print-directory, and recursion:      -w Option.
  115. * --print-directory, disabling:          -w Option.
  116. * --question <1>:                        Instead of Execution.
  117. * --question:                            Options Summary.
  118. * --quiet <1>:                           Echoing.
  119. * --quiet:                               Options Summary.
  120. * --recon <1>:                           Options Summary.
  121. * --recon <2>:                           Echoing.
  122. * --recon:                               Instead of Execution.
  123. * --silent <1>:                          Options Summary.
  124. * --silent:                              Echoing.
  125. * --stop:                                Options Summary.
  126. * --touch <1>:                           Options Summary.
  127. * --touch:                               Instead of Execution.
  128. * --touch, and recursion:                MAKE Variable.
  129. * --version:                             Options Summary.
  130. * --warn-undefined-variables:            Options Summary.
  131. * --what-if <1>:                         Options Summary.
  132. * --what-if:                             Instead of Execution.
  133. * -b:                                    Options Summary.
  134. * -C <1>:                                Recursion.
  135. * -C:                                    Options Summary.
  136. * -C, and -w:                            -w Option.
  137. * -C, and recursion:                     Options/Recursion.
  138. * -d:                                    Options Summary.
  139. * -e:                                    Options Summary.
  140. * -e (shell flag):                       Automatic Dependencies.
  141. * -f <1>:                                Options Summary.
  142. * -f <2>:                                Makefile Arguments.
  143. * -f:                                    Makefile Names.
  144. * -f, and recursion:                     Options/Recursion.
  145. * -h:                                    Options Summary.
  146. * -i:                                    Errors.
  147. * -I:                                    Options Summary.
  148. * -i:                                    Options Summary.
  149. * -I:                                    Include.
  150. * -j <1>:                                Parallel.
  151. * -j:                                    Options Summary.
  152. * -j, and archive update:                Archive Pitfalls.
  153. * -j, and recursion:                     Options/Recursion.
  154. * -k <1>:                                Testing.
  155. * -k <2>:                                Options Summary.
  156. * -k:                                    Errors.
  157. * -l:                                    Options Summary.
  158. * -l (library search):                   Libraries/Search.
  159. * -l (load average):                     Parallel.
  160. * -m:                                    Options Summary.
  161. * -M (to compiler):                      Automatic Dependencies.
  162. * -MM (to GNU compiler):                 Automatic Dependencies.
  163. * -n <1>:                                Instead of Execution.
  164. * -n <2>:                                Options Summary.
  165. * -n:                                    Echoing.
  166. * -o <1>:                                Options Summary.
  167. * -o:                                    Avoiding Compilation.
  168. * -o, and recursion:                     Options/Recursion.
  169. * -p:                                    Options Summary.
  170. * -q <1>:                                Instead of Execution.
  171. * -q:                                    Options Summary.
  172. * -r:                                    Options Summary.
  173. * -S:                                    Options Summary.
  174. * -s <1>:                                Options Summary.
  175. * -s:                                    Echoing.
  176. * -t <1>:                                Instead of Execution.
  177. * -t:                                    Options Summary.
  178. * -t, and recursion:                     MAKE Variable.
  179. * -v:                                    Options Summary.
  180. * -W:                                    Options Summary.
  181. * -w:                                    Options Summary.
  182. * -W:                                    Instead of Execution.
  183. * -w, and -C:                            -w Option.
  184. * -w, and recursion:                     -w Option.
  185. * -W, and recursion:                     Options/Recursion.
  186. * -w, disabling:                         -w Option.
  187. * .a (archives):                         Archive Suffix Rules.
  188. * .c:                                    Catalogue of Rules.
  189. * .C:                                    Catalogue of Rules.
  190. * .cc:                                   Catalogue of Rules.
  191. * .ch:                                   Catalogue of Rules.
  192. * .d:                                    Automatic Dependencies.
  193. * .def:                                  Catalogue of Rules.
  194. * .dvi:                                  Catalogue of Rules.
  195. * .f:                                    Catalogue of Rules.
  196. * .F:                                    Catalogue of Rules.
  197. * .info:                                 Catalogue of Rules.
  198. * .l:                                    Catalogue of Rules.
  199. * .ln:                                   Catalogue of Rules.
  200. * .mod:                                  Catalogue of Rules.
  201. * .o:                                    Catalogue of Rules.
  202. * .p:                                    Catalogue of Rules.
  203. * .PRECIOUS intermediate files:          Chained Rules.
  204. * .r:                                    Catalogue of Rules.
  205. * .s:                                    Catalogue of Rules.
  206. * .S:                                    Catalogue of Rules.
  207. * .sh:                                   Catalogue of Rules.
  208. * .sym:                                  Catalogue of Rules.
  209. * .tex:                                  Catalogue of Rules.
  210. * .texi:                                 Catalogue of Rules.
  211. * .texinfo:                              Catalogue of Rules.
  212. * .txinfo:                               Catalogue of Rules.
  213. * .w:                                    Catalogue of Rules.
  214. * .web:                                  Catalogue of Rules.
  215. * .y:                                    Catalogue of Rules.
  216. * :: rules (double-colon):               Double-Colon.
  217. * := <1>:                                Flavors.
  218. * :=:                                    Setting.
  219. * = <1>:                                 Flavors.
  220. * =:                                     Setting.
  221. * ? (wildcard character):                Wildcards.
  222. * @ (in commands):                       Echoing.
  223. * @, and define:                         Sequences.
  224. * [...] (wildcard characters):           Wildcards.
  225. * \ (backslash), for continuation lines: Simple Makefile.
  226. * \ (backslash), in commands:            Execution.
  227. * \ (backslash), to quote % <1>:         Selective Search.
  228. * \ (backslash), to quote % <2>:         Static Usage.
  229. * \ (backslash), to quote %:             Text Functions.
  230. * __.SYMDEF:                             Archive Symbols.
  231. * algorithm for directory search:        Search Algorithm.
  232. * all (standard target):                 Goals.
  233. * appending to variables:                Appending.
  234. * ar:                                    Implicit Variables.
  235. * archive:                               Archives.
  236. * archive member targets:                Archive Members.
  237. * archive symbol directory updating:     Archive Symbols.
  238. * archive, and -j:                       Archive Pitfalls.
  239. * archive, and parallel execution:       Archive Pitfalls.
  240. * archive, suffix rule for:              Archive Suffix Rules.
  241. * Arg list too long:                     Options/Recursion.
  242. * arguments of functions:                Syntax of Functions.
  243. * as <1>:                                Implicit Variables.
  244. * as:                                    Catalogue of Rules.
  245. * assembly, rule to compile:             Catalogue of Rules.
  246. * automatic generation of dependencies <1>: Automatic Dependencies.
  247. * automatic generation of dependencies:  Include.
  248. * automatic variables:                   Automatic.
  249. * backquotes:                            Shell Function.
  250. * backslash (\), for continuation lines: Simple Makefile.
  251. * backslash (\), in commands:            Execution.
  252. * backslash (\), to quote % <1>:         Selective Search.
  253. * backslash (\), to quote % <2>:         Text Functions.
  254. * backslash (\), to quote %:             Static Usage.
  255. * backslashes in pathnames and wildcard expansion: Wildcard Pitfall.
  256. * basename:                              File Name Functions.
  257. * binary packages:                       Install Command Categories.
  258. * broken pipe:                           Parallel.
  259. * bugs, reporting:                       Bugs.
  260. * built-in special targets:              Special Targets.
  261. * C++, rule to compile:                  Catalogue of Rules.
  262. * C, rule to compile:                    Catalogue of Rules.
  263. * cc <1>:                                Implicit Variables.
  264. * cc:                                    Catalogue of Rules.
  265. * cd (shell command) <1>:                Execution.
  266. * cd (shell command):                    MAKE Variable.
  267. * chains of rules:                       Chained Rules.
  268. * check (standard target):               Goals.
  269. * clean (standard target):               Goals.
  270. * clean target <1>:                      Simple Makefile.
  271. * clean target:                          Cleanup.
  272. * cleaning up:                           Cleanup.
  273. * clobber (standard target):             Goals.
  274. * co <1>:                                Catalogue of Rules.
  275. * co:                                    Implicit Variables.
  276. * combining rules by dependency:         Combine By Dependency.
  277. * command line variable definitions, and recursion: Options/Recursion.
  278. * command line variables:                Overriding.
  279. * commands:                              Rule Syntax.
  280. * commands, backslash (\) in:            Execution.
  281. * commands, comments in:                 Commands.
  282. * commands, echoing:                     Echoing.
  283. * commands, empty:                       Empty Commands.
  284. * commands, errors in:                   Errors.
  285. * commands, execution:                   Execution.
  286. * commands, execution in parallel:       Parallel.
  287. * commands, expansion:                   Shell Function.
  288. * commands, how to write:                Commands.
  289. * commands, instead of executing:        Instead of Execution.
  290. * commands, introduction to:             Rule Introduction.
  291. * commands, quoting newlines in:         Execution.
  292. * commands, sequences of:                Sequences.
  293. * comments, in commands:                 Commands.
  294. * comments, in makefile:                 Makefile Contents.
  295. * compatibility:                         Features.
  296. * compatibility in exporting:            Variables/Recursion.
  297. * compilation, testing:                  Testing.
  298. * computed variable name:                Computed Names.
  299. * conditionals:                          Conditionals.
  300. * continuation lines:                    Simple Makefile.
  301. * conventions for makefiles:             Makefile Conventions.
  302. * ctangle <1>:                           Implicit Variables.
  303. * ctangle:                               Catalogue of Rules.
  304. * cweave <1>:                            Implicit Variables.
  305. * cweave:                                Catalogue of Rules.
  306. * deducing commands (implicit rules):    make Deduces.
  307. * default directries for included makefiles: Include.
  308. * default goal <1>:                      How Make Works.
  309. * default goal:                          Rules.
  310. * default makefile name:                 Makefile Names.
  311. * default rules, last-resort:            Last Resort.
  312. * defining variables verbatim:           Defining.
  313. * deletion of target files <1>:          Interrupts.
  314. * deletion of target files:              Errors.
  315. * dependencies:                          Rule Syntax.
  316. * dependencies, automatic generation <1>: Include.
  317. * dependencies, automatic generation:    Automatic Dependencies.
  318. * dependencies, introduction to:         Rule Introduction.
  319. * dependencies, list of all:             Automatic.
  320. * dependencies, list of changed:         Automatic.
  321. * dependencies, varying (static pattern): Static Pattern.
  322. * dependency:                            Rules.
  323. * dependency pattern, implicit:          Pattern Intro.
  324. * dependency pattern, static (not implicit): Static Usage.
  325. * directive:                             Makefile Contents.
  326. * directories, printing them:            -w Option.
  327. * directories, updating archive symbol:  Archive Symbols.
  328. * directory part:                        File Name Functions.
  329. * directory search (VPATH):              Directory Search.
  330. * directory search (VPATH), and implicit rules: Implicit/Search.
  331. * directory search (VPATH), and link libraries: Libraries/Search.
  332. * directory search (VPATH), and shell commands: Commands/Search.
  333. * directory search algorithm:            Search Algorithm.
  334. * directory search, traditional:         Search Algorithm.
  335. * dist (standard target):                Goals.
  336. * distclean (standard target):           Goals.
  337. * dollar sign ($), in function call:     Syntax of Functions.
  338. * dollar sign ($), in rules:             Rule Syntax.
  339. * dollar sign ($), in variable name:     Computed Names.
  340. * dollar sign ($), in variable reference: Reference.
  341. * double-colon rules:                    Double-Colon.
  342. * duplicate words, removing:             Text Functions.
  343. * E2BIG:                                 Options/Recursion.
  344. * echoing of commands:                   Echoing.
  345. * editor:                                Introduction.
  346. * Emacs (M-x compile):                   Errors.
  347. * empty commands:                        Empty Commands.
  348. * empty targets:                         Empty Targets.
  349. * environment:                           Environment.
  350. * environment, and recursion:            Variables/Recursion.
  351. * environment, SHELL in:                 Execution.
  352. * errors (in commands):                  Errors.
  353. * errors with wildcards:                 Wildcard Pitfall.
  354. * execution, in parallel:                Parallel.
  355. * execution, instead of:                 Instead of Execution.
  356. * execution, of commands:                Execution.
  357. * exit status (errors):                  Errors.
  358. * explicit rule, definition of:          Makefile Contents.
  359. * exporting variables:                   Variables/Recursion.
  360. * f77 <1>:                               Implicit Variables.
  361. * f77:                                   Catalogue of Rules.
  362. * features of GNU make:                  Features.
  363. * features, missing:                     Missing.
  364. * file name functions:                   File Name Functions.
  365. * file name of makefile:                 Makefile Names.
  366. * file name of makefile, how to specify: Makefile Names.
  367. * file name prefix, adding:              File Name Functions.
  368. * file name suffix:                      File Name Functions.
  369. * file name suffix, adding:              File Name Functions.
  370. * file name with wildcards:              Wildcards.
  371. * file name, basename of:                File Name Functions.
  372. * file name, directory part:             File Name Functions.
  373. * file name, nondirectory part:          File Name Functions.
  374. * files, assuming new:                   Instead of Execution.
  375. * files, assuming old:                   Avoiding Compilation.
  376. * files, avoiding recompilation of:      Avoiding Compilation.
  377. * files, intermediate:                   Chained Rules.
  378. * filtering out words:                   Text Functions.
  379. * filtering words:                       Text Functions.
  380. * finding strings:                       Text Functions.
  381. * flags:                                 Options Summary.
  382. * flags for compilers:                   Implicit Variables.
  383. * flavors of variables:                  Flavors.
  384. * FORCE:                                 Force Targets.
  385. * force targets:                         Force Targets.
  386. * Fortran, rule to compile:              Catalogue of Rules.
  387. * functions:                             Functions.
  388. * functions, for file names:             File Name Functions.
  389. * functions, for text:                   Text Functions.
  390. * functions, syntax of:                  Syntax of Functions.
  391. * g++ <1>:                               Implicit Variables.
  392. * g++:                                   Catalogue of Rules.
  393. * gcc:                                   Catalogue of Rules.
  394. * generating dependencies automatically <1>: Automatic Dependencies.
  395. * generating dependencies automatically: Include.
  396. * get <1>:                               Implicit Variables.
  397. * get:                                   Catalogue of Rules.
  398. * globbing (wildcards):                  Wildcards.
  399. * goal:                                  How Make Works.
  400. * goal, default <1>:                     Rules.
  401. * goal, default:                         How Make Works.
  402. * goal, how to specify:                  Goals.
  403. * home directory:                        Wildcards.
  404. * IEEE Standard 1003.2:                  Overview.
  405. * implicit rule:                         Implicit Rules.
  406. * implicit rule, and directory search:   Implicit/Search.
  407. * implicit rule, and VPATH:              Implicit/Search.
  408. * implicit rule, definition of:          Makefile Contents.
  409. * implicit rule, how to use:             Using Implicit.
  410. * implicit rule, introduction to:        make Deduces.
  411. * implicit rule, predefined:             Catalogue of Rules.
  412. * implicit rule, search algorithm:       Implicit Rule Search.
  413. * included makefiles, default directries: Include.
  414. * including (MAKEFILES variable):        MAKEFILES Variable.
  415. * including other makefiles:             Include.
  416. * incompatibilities:                     Missing.
  417. * Info, rule to format:                  Catalogue of Rules.
  418. * install (standard target):             Goals.
  419. * intermediate files:                    Chained Rules.
  420. * intermediate files, preserving:        Chained Rules.
  421. * intermediate targets, explicit:        Special Targets.
  422. * interrupt:                             Interrupts.
  423. * job slots:                             Parallel.
  424. * job slots, and recursion:              Options/Recursion.
  425. * jobs, limiting based on load:          Parallel.
  426. * joining lists of words:                File Name Functions.
  427. * killing (interruption):                Interrupts.
  428. * last-resort default rules:             Last Resort.
  429. * ld:                                    Catalogue of Rules.
  430. * lex <1>:                               Implicit Variables.
  431. * lex:                                   Catalogue of Rules.
  432. * Lex, rule to run:                      Catalogue of Rules.
  433. * libraries for linking, directory search: Libraries/Search.
  434. * library archive, suffix rule for:      Archive Suffix Rules.
  435. * limiting jobs based on load:           Parallel.
  436. * link libraries, and directory search:  Libraries/Search.
  437. * linking, predefined rule for:          Catalogue of Rules.
  438. * lint:                                  Catalogue of Rules.
  439. * lint, rule to run:                     Catalogue of Rules.
  440. * list of all dependencies:              Automatic.
  441. * list of changed dependencies:          Automatic.
  442. * load average:                          Parallel.
  443. * loops in variable expansion:           Flavors.
  444. * lpr (shell command) <1>:               Wildcard Examples.
  445. * lpr (shell command):                   Empty Targets.
  446. * m2c:                                   Catalogue of Rules.
  447. * macro:                                 Using Variables.
  448. * make depend:                           Automatic Dependencies.
  449. * MAKECMDGOALS:                          Goals.
  450. * makefile:                              Introduction.
  451. * makefile name:                         Makefile Names.
  452. * makefile name, how to specify:         Makefile Names.
  453. * makefile rule parts:                   Rule Introduction.
  454. * makefile, and MAKEFILES variable:      MAKEFILES Variable.
  455. * makefile, conventions for:             Makefile Conventions.
  456. * makefile, how make processes:          How Make Works.
  457. * makefile, how to write:                Makefiles.
  458. * makefile, including:                   Include.
  459. * makefile, overriding:                  Overriding Makefiles.
  460. * makefile, remaking of:                 Remaking Makefiles.
  461. * makefile, simple:                      Simple Makefile.
  462. * makeinfo <1>:                          Implicit Variables.
  463. * makeinfo:                              Catalogue of Rules.
  464. * match-anything rule:                   Match-Anything Rules.
  465. * match-anything rule, used to override: Overriding Makefiles.
  466. * missing features:                      Missing.
  467. * mistakes with wildcards:               Wildcard Pitfall.
  468. * modified variable reference:           Substitution Refs.
  469. * Modula-2, rule to compile:             Catalogue of Rules.
  470. * mostlyclean (standard target):         Goals.
  471. * multiple rules for one target:         Multiple Rules.
  472. * multiple rules for one target (::):    Double-Colon.
  473. * multiple targets:                      Multiple Targets.
  474. * multiple targets, in pattern rule:     Pattern Intro.
  475. * name of makefile:                      Makefile Names.
  476. * name of makefile, how to specify:      Makefile Names.
  477. * nested variable reference:             Computed Names.
  478. * newline, quoting, in commands:         Execution.
  479. * newline, quoting, in makefile:         Simple Makefile.
  480. * nondirectory part:                     File Name Functions.
  481. * obj:                                   Variables Simplify.
  482. * OBJ:                                   Variables Simplify.
  483. * OBJECTS:                               Variables Simplify.
  484. * objects:                               Variables Simplify.
  485. * objs:                                  Variables Simplify.
  486. * OBJS:                                  Variables Simplify.
  487. * old-fashioned suffix rules:            Suffix Rules.
  488. * options:                               Options Summary.
  489. * options, and recursion:                Options/Recursion.
  490. * options, setting from environment:     Options/Recursion.
  491. * options, setting in makefiles:         Options/Recursion.
  492. * order of pattern rules:                Pattern Intro.
  493. * origin of variable:                    Origin Function.
  494. * overriding makefiles:                  Overriding Makefiles.
  495. * overriding variables with arguments:   Overriding.
  496. * overriding with override:              Override Directive.
  497. * parallel execution:                    Parallel.
  498. * parallel execution, and archive update: Archive Pitfalls.
  499. * parts of makefile rule:                Rule Introduction.
  500. * Pascal, rule to compile:               Catalogue of Rules.
  501. * pattern rule:                          Pattern Intro.
  502. * pattern rules, order of:               Pattern Intro.
  503. * pattern rules, static (not implicit):  Static Pattern.
  504. * pattern rules, static, syntax of:      Static Usage.
  505. * pc <1>:                                Implicit Variables.
  506. * pc:                                    Catalogue of Rules.
  507. * phony targets:                         Phony Targets.
  508. * pitfalls of wildcards:                 Wildcard Pitfall.
  509. * portability:                           Features.
  510. * POSIX:                                 Overview.
  511. * POSIX.2:                               Options/Recursion.
  512. * post-installation commands:            Install Command Categories.
  513. * pre-installation commands:             Install Command Categories.
  514. * precious targets:                      Special Targets.
  515. * prefix, adding:                        File Name Functions.
  516. * preserving intermediate files:         Chained Rules.
  517. * preserving with .PRECIOUS <1>:         Chained Rules.
  518. * preserving with .PRECIOUS:             Special Targets.
  519. * preserving with .SECONDARY:            Special Targets.
  520. * print (standard target):               Goals.
  521. * print target <1>:                      Empty Targets.
  522. * print target:                          Wildcard Examples.
  523. * printing directories:                  -w Option.
  524. * printing of commands:                  Echoing.
  525. * problems and bugs, reporting:          Bugs.
  526. * problems with wildcards:               Wildcard Pitfall.
  527. * processing a makefile:                 How Make Works.
  528. * question mode:                         Instead of Execution.
  529. * quoting %, in patsubst:                Text Functions.
  530. * quoting %, in static pattern:          Static Usage.
  531. * quoting %, in vpath:                   Selective Search.
  532. * quoting newline, in commands:          Execution.
  533. * quoting newline, in makefile:          Simple Makefile.
  534. * Ratfor, rule to compile:               Catalogue of Rules.
  535. * RCS, rule to extract from:             Catalogue of Rules.
  536. * README:                                Makefile Names.
  537. * realclean (standard target):           Goals.
  538. * recompilation:                         Introduction.
  539. * recompilation, avoiding:               Avoiding Compilation.
  540. * recording events with empty targets:   Empty Targets.
  541. * recursion:                             Recursion.
  542. * recursion, and -C:                     Options/Recursion.
  543. * recursion, and -f:                     Options/Recursion.
  544. * recursion, and -j:                     Options/Recursion.
  545. * recursion, and -o:                     Options/Recursion.
  546. * recursion, and -t:                     MAKE Variable.
  547. * recursion, and -W:                     Options/Recursion.
  548. * recursion, and -w:                     -w Option.
  549. * recursion, and command line variable definitions: Options/Recursion.
  550. * recursion, and environment:            Variables/Recursion.
  551. * recursion, and MAKE variable:          MAKE Variable.
  552. * recursion, and MAKEFILES variable:     MAKEFILES Variable.
  553. * recursion, and options:                Options/Recursion.
  554. * recursion, and printing directories:   -w Option.
  555. * recursion, and variables:              Variables/Recursion.
  556. * recursion, level of:                   Variables/Recursion.
  557. * recursive variable expansion <1>:      Flavors.
  558. * recursive variable expansion:          Using Variables.
  559. * recursively expanded variables:        Flavors.
  560. * reference to variables <1>:            Reference.
  561. * reference to variables:                Advanced.
  562. * relinking:                             How Make Works.
  563. * remaking makefiles:                    Remaking Makefiles.
  564. * removal of target files <1>:           Errors.
  565. * removal of target files:               Interrupts.
  566. * removing duplicate words:              Text Functions.
  567. * removing, to clean up:                 Cleanup.
  568. * reporting bugs:                        Bugs.
  569. * rm:                                    Implicit Variables.
  570. * rm (shell command) <1>:                Wildcard Examples.
  571. * rm (shell command) <2>:                Errors.
  572. * rm (shell command) <3>:                Phony Targets.
  573. * rm (shell command):                    Simple Makefile.
  574. * rule commands:                         Commands.
  575. * rule dependencies:                     Rule Syntax.
  576. * rule syntax:                           Rule Syntax.
  577. * rule targets:                          Rule Syntax.
  578. * rule, and $:                           Rule Syntax.
  579. * rule, double-colon (::):               Double-Colon.
  580. * rule, explicit, definition of:         Makefile Contents.
  581. * rule, how to write:                    Rules.
  582. * rule, implicit:                        Implicit Rules.
  583. * rule, implicit, and directory search:  Implicit/Search.
  584. * rule, implicit, and VPATH:             Implicit/Search.
  585. * rule, implicit, chains of:             Chained Rules.
  586. * rule, implicit, definition of:         Makefile Contents.
  587. * rule, implicit, how to use:            Using Implicit.
  588. * rule, implicit, introduction to:       make Deduces.
  589. * rule, implicit, predefined:            Catalogue of Rules.
  590. * rule, introduction to:                 Rule Introduction.
  591. * rule, multiple for one target:         Multiple Rules.
  592. * rule, no commands or dependencies:     Force Targets.
  593. * rule, pattern:                         Pattern Intro.
  594. * rule, static pattern:                  Static Pattern.
  595. * rule, static pattern versus implicit:  Static versus Implicit.
  596. * rule, with multiple targets:           Multiple Targets.
  597. * s. (SCCS file prefix):                 Catalogue of Rules.
  598. * SCCS, rule to extract from:            Catalogue of Rules.
  599. * search algorithm, implicit rule:       Implicit Rule Search.
  600. * search path for dependencies (VPATH):  Directory Search.
  601. * search path for dependencies (VPATH), and implicit rules: Implicit/Search.
  602. * search path for dependencies (VPATH), and link libraries: Libraries/Search.
  603. * searching for strings:                 Text Functions.
  604. * secondary files:                       Chained Rules.
  605. * secondary targets:                     Special Targets.
  606. * sed (shell command):                   Automatic Dependencies.
  607. * selecting a word:                      File Name Functions.
  608. * selecting word lists:                  File Name Functions.
  609. * sequences of commands:                 Sequences.
  610. * setting options from environment:      Options/Recursion.
  611. * setting options in makefiles:          Options/Recursion.
  612. * setting variables:                     Setting.
  613. * several rules for one target:          Multiple Rules.
  614. * several targets in a rule:             Multiple Targets.
  615. * shar (standard target):                Goals.
  616. * shell command:                         Simple Makefile.
  617. * shell command, and directory search:   Commands/Search.
  618. * shell command, execution:              Execution.
  619. * shell command, function for:           Shell Function.
  620. * shell file name pattern (in include):  Include.
  621. * shell wildcards (in include):          Include.
  622. * SHELL, MS-DOS specifics:               Execution.
  623. * signal:                                Interrupts.
  624. * silent operation:                      Echoing.
  625. * simple makefile:                       Simple Makefile.
  626. * simple variable expansion:             Using Variables.
  627. * simplifying with variables:            Variables Simplify.
  628. * simply expanded variables:             Flavors.
  629. * sorting words:                         Text Functions.
  630. * spaces, in variable values:            Flavors.
  631. * spaces, stripping:                     Text Functions.
  632. * special targets:                       Special Targets.
  633. * specifying makefile name:              Makefile Names.
  634. * standard input:                        Parallel.
  635. * standards conformance:                 Overview.
  636. * standards for makefiles:               Makefile Conventions.
  637. * static pattern rule:                   Static Pattern.
  638. * static pattern rule, syntax of:        Static Usage.
  639. * static pattern rule, versus implicit:  Static versus Implicit.
  640. * stem <1>:                              Pattern Match.
  641. * stem:                                  Static Usage.
  642. * stem, variable for:                    Automatic.
  643. * strings, searching for:                Text Functions.
  644. * stripping whitespace:                  Text Functions.
  645. * sub-make:                              Variables/Recursion.
  646. * subdirectories, recursion for:         Recursion.
  647. * substitution variable reference:       Substitution Refs.
  648. * suffix rule:                           Suffix Rules.
  649. * suffix rule, for archive:              Archive Suffix Rules.
  650. * suffix, adding:                        File Name Functions.
  651. * suffix, function to find:              File Name Functions.
  652. * suffix, substituting in variables:     Substitution Refs.
  653. * switches:                              Options Summary.
  654. * symbol directories, updating archive:  Archive Symbols.
  655. * syntax of rules:                       Rule Syntax.
  656. * tab character (in commands):           Rule Syntax.
  657. * tabs in rules:                         Rule Introduction.
  658. * TAGS (standard target):                Goals.
  659. * tangle <1>:                            Implicit Variables.
  660. * tangle:                                Catalogue of Rules.
  661. * tar (standard target):                 Goals.
  662. * target:                                Rules.
  663. * target pattern, implicit:              Pattern Intro.
  664. * target pattern, static (not implicit): Static Usage.
  665. * target, deleting on error:             Errors.
  666. * target, deleting on interrupt:         Interrupts.
  667. * target, multiple in pattern rule:      Pattern Intro.
  668. * target, multiple rules for one:        Multiple Rules.
  669. * target, touching:                      Instead of Execution.
  670. * targets:                               Rule Syntax.
  671. * targets without a file:                Phony Targets.
  672. * targets, built-in special:             Special Targets.
  673. * targets, empty:                        Empty Targets.
  674. * targets, force:                        Force Targets.
  675. * targets, introduction to:              Rule Introduction.
  676. * targets, multiple:                     Multiple Targets.
  677. * targets, phony:                        Phony Targets.
  678. * terminal rule:                         Match-Anything Rules.
  679. * test (standard target):                Goals.
  680. * testing compilation:                   Testing.
  681. * tex <1>:                               Catalogue of Rules.
  682. * tex:                                   Implicit Variables.
  683. * TeX, rule to run:                      Catalogue of Rules.
  684. * texi2dvi <1>:                          Implicit Variables.
  685. * texi2dvi:                              Catalogue of Rules.
  686. * Texinfo, rule to format:               Catalogue of Rules.
  687. * tilde (~):                             Wildcards.
  688. * touch (shell command) <1>:             Wildcard Examples.
  689. * touch (shell command):                 Empty Targets.
  690. * touching files:                        Instead of Execution.
  691. * traditional directory search:          Search Algorithm.
  692. * undefined variables, warning message:  Options Summary.
  693. * updating archive symbol directories:   Archive Symbols.
  694. * updating makefiles:                    Remaking Makefiles.
  695. * value:                                 Using Variables.
  696. * value, how a variable gets it:         Values.
  697. * variable:                              Using Variables.
  698. * variable definition:                   Makefile Contents.
  699. * variables:                             Variables Simplify.
  700. * variables, $ in name:                  Computed Names.
  701. * variables, and implicit rule:          Automatic.
  702. * variables, appending to:               Appending.
  703. * variables, automatic:                  Automatic.
  704. * variables, command line:               Overriding.
  705. * variables, command line, and recursion: Options/Recursion.
  706. * variables, computed names:             Computed Names.
  707. * variables, defining verbatim:          Defining.
  708. * variables, environment <1>:            Variables/Recursion.
  709. * variables, environment:                Environment.
  710. * variables, exporting:                  Variables/Recursion.
  711. * variables, flavors:                    Flavors.
  712. * variables, how they get their values:  Values.
  713. * variables, how to reference:           Reference.
  714. * variables, loops in expansion:         Flavors.
  715. * variables, modified reference:         Substitution Refs.
  716. * variables, nested references:          Computed Names.
  717. * variables, origin of:                  Origin Function.
  718. * variables, overriding:                 Override Directive.
  719. * variables, overriding with arguments:  Overriding.
  720. * variables, recursively expanded:       Flavors.
  721. * variables, setting:                    Setting.
  722. * variables, simply expanded:            Flavors.
  723. * variables, spaces in values:           Flavors.
  724. * variables, substituting suffix in:     Substitution Refs.
  725. * variables, substitution reference:     Substitution Refs.
  726. * variables, warning for undefined:      Options Summary.
  727. * varying dependencies:                  Static Pattern.
  728. * verbatim variable definition:          Defining.
  729. * vpath:                                 Directory Search.
  730. * VPATH, and implicit rules:             Implicit/Search.
  731. * VPATH, and link libraries:             Libraries/Search.
  732. * weave <1>:                             Catalogue of Rules.
  733. * weave:                                 Implicit Variables.
  734. * Web, rule to run:                      Catalogue of Rules.
  735. * what if:                               Instead of Execution.
  736. * whitespace, in variable values:        Flavors.
  737. * whitespace, stripping:                 Text Functions.
  738. * wildcard:                              Wildcards.
  739. * wildcard pitfalls:                     Wildcard Pitfall.
  740. * wildcard, function:                    File Name Functions.
  741. * wildcard, in archive member:           Archive Members.
  742. * wildcard, in include:                  Include.
  743. * wildcards and MS-DOS/MS-Windows backslashes: Wildcard Pitfall.
  744. * word, selecting a:                     File Name Functions.
  745. * words, extracting first:               File Name Functions.
  746. * words, filtering:                      Text Functions.
  747. * words, filtering out:                  Text Functions.
  748. * words, finding number:                 File Name Functions.
  749. * words, iterating over:                 Foreach Function.
  750. * words, joining lists:                  File Name Functions.
  751. * words, removing duplicates:            Text Functions.
  752. * words, selecting lists of:             File Name Functions.
  753. * writing rule commands:                 Commands.
  754. * writing rules:                         Rules.
  755. * yacc <1>:                              Sequences.
  756. * yacc <2>:                              Implicit Variables.
  757. * yacc:                                  Catalogue of Rules.
  758. * Yacc, rule to run:                     Catalogue of Rules.
  759. * ~ (tilde):                             Wildcards.
  760.  
  761.